home *** CD-ROM | disk | FTP | other *** search
/ Aminet 28 / Aminet 28 (1998)(GTI - Schatztruhe)[!][Dec 1998].iso / Aminet / comm / fido / ConvPktSrc.lha / ConvPkt / ConvPkt15.c < prev    next >
C/C++ Source or Header  |  1997-06-19  |  21KB  |  920 lines
  1. #include <exec/types.h>
  2. #include <exec/memory.h>
  3. #include <exec/execbase.h>
  4. #include <dos/dos.h>
  5.  
  6. #include <FidoNet.h>
  7. #include <jbio.h>
  8. #include <CharTabs.h>
  9.  
  10. #include <stdlib.h>
  11. #include <string.h>
  12.  
  13. #include <clib/alib_protos.h>
  14. #include <clib/exec_protos.h>
  15. #include <clib/dos_protos.h>
  16.  
  17. #define VERSION "1.5"
  18.  
  19. UBYTE *ver="\0$VER: ConvPkt "VERSION" ("__COMMODORE_DATE__")";
  20.  
  21. struct jbList
  22. {
  23.    struct jbNode *First;
  24.    struct jbNode *Last;
  25. };
  26.  
  27. struct jbNode
  28. {
  29.    struct jbNode *Next;
  30. };
  31.  
  32. struct ChrsNode
  33. {
  34.    struct jbNode Node;
  35.    UBYTE parsedpattern[200];
  36.    UBYTE *chrs;
  37.    UBYTE *defaultchrs;
  38. };
  39.  
  40. struct jbList ChrsList;
  41.  
  42. jbNewList(struct jbList *list);
  43. jbAddNode(struct jbList *list, struct jbNode *node);
  44. jbFreeList(struct jbList *list,struct jbNode *firstnode,ULONG sizenode);
  45. jbFreeNum(struct jbList *list,ULONG num,ULONG size);
  46. jbFreeNode(struct jbList *list,struct jbNode *node,ULONG size);
  47.  
  48. #define PKT_MINREADLEN  200
  49. #define PKT_CHUNKLEN  10000
  50.  
  51. struct TextChunk
  52. {
  53.    struct TextChunk *Next;
  54.    ULONG Length;
  55.    UBYTE Data[PKT_CHUNKLEN];
  56. };
  57.  
  58. extern struct ExecBase *SysBase;
  59.  
  60. struct FileNode
  61. {
  62.    struct Node Node;
  63.    UBYTE File[200];
  64. };
  65.  
  66. struct List FileList;
  67.  
  68. #define ARG_FILE           0
  69. #define ARG_TO             1
  70. #define ARG_CHRSLIST       2
  71. #define ARG_DEFAULTCHRS    3
  72. #define ARG_IGNORECHRS     4
  73. #define ARG_NOCHRS         5
  74. #define ARG_CHRSONLY       6
  75. #define ARG_CP865          7
  76.  
  77. UBYTE *argstring="FILE/A,TOCHRS=TO,CHRSLIST/K,DEFAULTCHRS=DEFCHRS/K,IGNORECHRS/S,NOCHRS/S,CHRSONLY/S,CP865/S";
  78. ULONG argarray[8];
  79.  
  80. struct PktHeader PktHeader;
  81. struct PktMsgHeader PktMsgHeader;
  82.  
  83. UBYTE Msg_To[36];
  84. UBYTE Msg_From[36];
  85. UBYTE Msg_Subject[72];
  86. UBYTE Msg_DateTime[20];
  87. UBYTE Msg_CHRS[50];
  88. UBYTE Msg_Area[100];
  89.  
  90. struct jbList Msg_TextChunks;
  91.  
  92. BOOL longread,shortread,nomem,diskfull,messageend;
  93. BOOL brk;
  94.  
  95. #define CHARSET_SKIP    -1
  96.  
  97. BOOL cmd_ignorechrs;
  98. BOOL cmd_nochrs;
  99. BOOL cmd_chrsonly;
  100. UBYTE *cmd_chrs;
  101. UBYTE *cmd_defaultchrs;
  102.  
  103. struct RDArgs *rdargs;
  104.  
  105. Xlat(UBYTE *buf,UBYTE *chrs,ULONG len)
  106. {
  107.    ULONG c;
  108.  
  109.    if(argarray[ARG_CP865])
  110.    {
  111.       if(chrs == IbmToAmiga) chrs=IbnToAmiga;
  112.       if(chrs == AmigaToIbm) chrs=AmigaToIbn;
  113.       if(chrs == DefToAmiga) chrs=DfnToAmiga;
  114.    }
  115.  
  116.    if(!chrs)
  117.       return;
  118.  
  119.    for(c=0;c<len;c++)
  120.    {
  121.       if(buf[c]!=0 && chrs[buf[c]]==0)
  122.          buf[c]='?';
  123.  
  124.       else
  125.          buf[c]=chrs[buf[c]];
  126.    }
  127. }
  128.  
  129. UBYTE *GetCharset(UBYTE *string,UBYTE *defchrs)
  130. {
  131.    if(strncmp(string,"IBMPC",5)==0)
  132.       return(IbmToAmiga);
  133.  
  134.    else if(strncmp(string,"SWEDISH",7)==0)
  135.       return(SF7ToAmiga);
  136.  
  137.    else if(strncmp(string,"MAC",3)==0)
  138.       return(MacToAmiga);
  139.  
  140.    else if(strncmp(string,"LATIN",5)==0)
  141.       return(NULL);
  142.  
  143.    return(defchrs);
  144. }
  145.  
  146.  
  147. ProcessKludge(UBYTE *kludge, ULONG klen)
  148. {
  149.    if(strncmp(kludge,"\x01CHRS:",6)==0)
  150.    {
  151.       strncpy(Msg_CHRS,&kludge[7],49);
  152.       if(klen-11<49) Msg_CHRS[klen-8]=0;
  153.       else           Msg_CHRS[49]=0;
  154.       klen=0;
  155.    }
  156.  
  157.    if(strncmp(kludge,"\x01CHARSET:",9)==0)
  158.    {
  159.       strncpy(Msg_CHRS,&kludge[10],49);
  160.       if(klen-11<49) Msg_CHRS[klen-11]=0;
  161.       else           Msg_CHRS[49]=0;
  162.       klen=0;
  163.    }
  164.  
  165.    return(klen);
  166. }
  167.  
  168. ULONG ReadNull(UBYTE *buf, ULONG maxlen, struct jbFile *jb)
  169. {
  170.    /* Reads from jb until buffer full or NULL */
  171.  
  172.    WORD ch,c=0;
  173.  
  174.    if(shortread) return(0);
  175.  
  176.    ch=jbGetChar(jb);
  177.  
  178.    while(ch!=-1 && ch!=0 && c!=maxlen-1)
  179.    {
  180.       buf[c++]=ch;
  181.       ch=jbGetChar(jb);
  182.    }
  183.    buf[c]=0;
  184.  
  185.    if(ch==-1)
  186.       shortread=TRUE;
  187.  
  188.    if(ch!=0 && c==maxlen-1)
  189.       longread=TRUE;
  190.  
  191.    return(c);
  192. }
  193.  
  194. ULONG ReadCR(UBYTE *buf, ULONG maxlen, struct jbFile *jb)
  195. {
  196.    /* Reads from jb until buffer full or CR */
  197.  
  198.    WORD ch,c=0;
  199.  
  200.    ch=jbGetChar(jb);
  201.  
  202.    while(ch!=-1 && ch!=0 && ch!=10 && ch !=13 && c!=maxlen-1)
  203.    {
  204.       buf[c++]=ch;
  205.       ch=jbGetChar(jb);
  206.    }
  207.  
  208.    if(ch==13 || ch==10)
  209.       buf[c++]=ch;
  210.  
  211.    if(ch==0)  messageend=TRUE;
  212.    if(ch==-1) shortread=TRUE;
  213.  
  214.    return(c);
  215. }
  216.  
  217. void CleanMemMessage(void)
  218. {
  219.    if(Msg_TextChunks.First->Next)
  220.       jbFreeList(&Msg_TextChunks,Msg_TextChunks.First->Next,sizeof(struct TextChunk));
  221. }
  222.  
  223. BOOL WriteNull(struct jbFile *jb,UBYTE *str)
  224. {
  225.    jbWrite(jb,str,strlen(str)+1);
  226. }
  227.  
  228. ConvertPkt(UBYTE *file)
  229. {
  230.    struct TextChunk *ThisChunk;
  231.    ULONG rlen,msgnum;
  232.    struct jbFile *jbin,*jbout;
  233.    UBYTE out[200];
  234.    UBYTE *chrs;
  235.    struct TextChunk *chunk;
  236.    BOOL noconv;
  237.    UBYTE firstline[200];
  238.    UBYTE area[200];
  239.    UBYTE *destchrs,*defchrs;
  240.    ULONG c;
  241.    struct ChrsNode *chrsnode;
  242.    BPTR l;
  243.    struct FileInfoBlock *fib;
  244.  
  245.    Printf("Converting %s...\n",file);
  246.  
  247.    if(!(l=Lock(file,SHARED_LOCK)))
  248.    {
  249.       Printf("Unable to lock file\n");
  250.       return;
  251.    }
  252.  
  253.    if(!(fib=(struct FileInfoBlock *)AllocMem(sizeof(struct FileInfoBlock),MEMF_ANY)))
  254.    {
  255.       Printf("Out of memory\n");
  256.       UnLock(l);
  257.       return;
  258.    }
  259.  
  260.    Examine(l,fib);
  261.  
  262.    if(!(jbin=jbOpen(file,MODE_OLDFILE,10000)))
  263.    {
  264.       PrintFault(IoErr(),NULL);
  265.       UnLock(l);
  266.       FreeMem(fib,sizeof(struct FileInfoBlock));
  267.       return;
  268.    }
  269.  
  270.    strcpy(out,file);
  271.    strncat(out,".tmp",190);
  272.  
  273.    if(jbRead(jbin,&PktHeader,sizeof(struct PktHeader))!=sizeof(struct PktHeader))
  274.    {
  275.       Printf("Packet header is too short\n");
  276.       jbClose(jbin);
  277.       UnLock(l);
  278.       FreeMem(fib,sizeof(struct FileInfoBlock));
  279.       return;
  280.    }
  281.  
  282.    if(PktHeader.PktType!=0x0200)
  283.    {
  284.       Printf("Not a Type-2 packet\n");
  285.       jbClose(jbin);
  286.       UnLock(l);
  287.       FreeMem(fib,sizeof(struct FileInfoBlock));
  288.       return;
  289.    }
  290.  
  291.    if(!(jbout=jbOpen(out,MODE_NEWFILE,10000)))
  292.    {
  293.       jbClose(jbin);
  294.       PrintFault(IoErr(),NULL);
  295.       UnLock(l);
  296.       FreeMem(fib,sizeof(struct FileInfoBlock));
  297.       return;
  298.    }
  299.  
  300.    jbWrite(jbout,&PktHeader,sizeof(struct PktHeader));
  301.  
  302.    if(diskfull)
  303.    {
  304.       PrintFault(IoErr(),"I/O error");
  305.       jbClose(jbin);
  306.       jbClose(jbout);
  307.       DeleteFile(out);
  308.       UnLock(l);
  309.       FreeMem(fib,sizeof(struct FileInfoBlock));
  310.       return;
  311.    }
  312.  
  313.    shortread=FALSE;
  314.    longread=FALSE;
  315.  
  316.    if(jbRead(jbin,&PktMsgHeader,sizeof(struct PktMsgHeader)) < 2)
  317.    {
  318.       Printf("Message header for msg #1 is too short\n");
  319.       jbClose(jbin);
  320.       jbClose(jbout);
  321.       DeleteFile(out);
  322.       UnLock(l);
  323.       FreeMem(fib,sizeof(struct FileInfoBlock));
  324.       return;
  325.    }
  326.  
  327.    msgnum=0;
  328.  
  329.    while(PktMsgHeader.PktType==0x0200)
  330.    {
  331.       msgnum++;
  332.  
  333.       ((struct TextChunk *)Msg_TextChunks.First)->Length=NULL;
  334.       ThisChunk=Msg_TextChunks.First;
  335.  
  336.       /* Get header strings */
  337.  
  338.       Msg_CHRS[0]=0;
  339.       Msg_Area[0]=0;
  340.  
  341.       ReadNull(Msg_DateTime,20,jbin);
  342.       ReadNull(Msg_To,36,jbin);
  343.       ReadNull(Msg_From,36,jbin);
  344.       ReadNull(Msg_Subject,72,jbin);
  345.  
  346.       /* Corrupt packet? */
  347.  
  348.       if(shortread)
  349.       {
  350.          Printf("Message header for msg #%lu is short\n",msgnum);
  351.          jbClose(jbin);
  352.          jbClose(jbout);
  353.          DeleteFile(out);
  354.          UnLock(l);
  355.          FreeMem(fib,sizeof(struct FileInfoBlock));
  356.          return;
  357.       }
  358.  
  359.       if(longread)
  360.       {
  361.          Printf("Header strings too long in msg #%lu\n",msgnum);
  362.          jbClose(jbin);
  363.          jbClose(jbout);
  364.          DeleteFile(out);
  365.          UnLock(l);
  366.          FreeMem(fib,sizeof(struct FileInfoBlock));
  367.          return;
  368.       }
  369.  
  370.       messageend=FALSE;
  371.  
  372.       rlen=ReadCR(firstline,190,jbin);
  373.       firstline[rlen]=0;
  374.  
  375.       destchrs=cmd_chrs;
  376.       defchrs=cmd_defaultchrs;
  377.  
  378.       ThisChunk->Data[0]=0;
  379.  
  380.       if(strncmp(firstline,"AREA:",5)==0)
  381.       {
  382.          strcpy(area,&firstline[5]);
  383.          for(c=strlen(area);c;c--) if(area[c]<32) area[c]=0;
  384.          strcpy(Msg_Area,area);
  385.       }
  386.       else
  387.       {
  388.          strcpy(area,"NETMAIL");
  389.       }
  390.  
  391.       for(chrsnode=ChrsList.First;chrsnode;chrsnode=chrsnode->Node.Next)
  392.          if(MatchPatternNoCase(chrsnode->parsedpattern,area)) break;
  393.  
  394.       if(chrsnode)
  395.       {
  396.          destchrs=chrsnode->chrs;
  397.          defchrs=chrsnode->defaultchrs;
  398.       }
  399.  
  400.       ThisChunk->Length=strlen(ThisChunk->Data);
  401.  
  402.       if(strncmp(firstline,"AREA:",5)!=0)
  403.       {
  404.          strcat(ThisChunk->Data,firstline);
  405.  
  406.         if(ThisChunk->Data[ThisChunk->Length]==1 && destchrs!=(UBYTE *)CHARSET_SKIP)
  407.             rlen=ProcessKludge(&ThisChunk->Data[ThisChunk->Length],rlen);
  408.  
  409.          T